#ifndef DATA_FUSION_ENGINE_H
#define DATA_FUSION_ENGINE_H

#include "DataStructures.h"
#include <queue>
#include <mutex>
#include <condition_variable>
#include <thread>
#include <atomic>
#include <functional>

namespace Battlefield {

class DataFusionEngine {
public:
    using DataCallback = std::function<void(const DataPacket&)>;
    using SituationCallback = std::function<void(const BattlefieldSituation&)>;
    
    DataFusionEngine();
    ~DataFusionEngine();
    
    // 初始化引擎
    bool initialize(const std::map<std::string, std::string>& config);
    
    // 启动/停止引擎
    void start();
    void stop();
    
    // 注册数据源
    void registerDataSource(DataSourceType type, const std::string& endpoint);
    
    // 接收数据包
    void receiveData(const DataPacket& packet);
    
    // 注册回调函数
    void setDataCallback(DataCallback callback);
    void setSituationCallback(SituationCallback callback);
    
    // 获取当前态势
    BattlefieldSituation getCurrentSituation() const;
    
    // 设置数据源权重
    void setSourceWeights(const std::map<DataSourceType, double>& weights);
    
private:
    // 处理线程函数
    void processThread();
    
    // 处理单个数据包
    void processDataPacket(const DataPacket& packet);
    
    // 解析不同数据源
    std::vector<IdentifiedTarget> parseUAVData(const DataPacket& packet);
    std::vector<IdentifiedTarget> parseSatelliteData(const DataPacket& packet);
    std::vector<IdentifiedTarget> parseEMSensorData(const DataPacket& packet);
    
    // 融合多个数据源的目标识别结果
    std::vector<IdentifiedTarget> fuseTargets(
        const std::vector<std::vector<IdentifiedTarget>>& sourceTargets);
    
    // 更新战场态势
    void updateSituation(const std::vector<IdentifiedTarget>& newTargets);
    
    // 计算目标间的关联性
    double calculateTargetAssociation(const IdentifiedTarget& t1, 
                                      const IdentifiedTarget& t2) const;
    
    // 数据队列
    std::queue<DataPacket> dataQueue_;
    mutable std::mutex queueMutex_;
    std::condition_variable queueCV_;
    
    // 当前态势
    BattlefieldSituation currentSituation_;
    mutable std::mutex situationMutex_;
    
    // 处理线程
    std::thread processingThread_;
    std::atomic<bool> isRunning_{false};
    
    // 回调函数
    DataCallback dataCallback_;
    SituationCallback situationCallback_;
    
    // 配置参数
    std::map<DataSourceType, double> sourceWeights_;
    double confidenceThreshold_{0.7};
    double dataTimeoutSeconds_{5.0};
    int maxTrajectoryPoints_{50};
    
    // 数据源端点
    std::map<DataSourceType, std::string> dataSources_;
    
    // 统计信息
    struct {
        uint64_t packetsReceived{0};
        uint64_t packetsProcessed{0};
        uint64_t targetsIdentified{0};
        uint64_t fusionOperations{0};
    } statistics_;
    
    // 日志
    void log(const std::string& message, const std::string& level = "INFO");
};

} // namespace Battlefield

#endif // DATA_FUSION_ENGINE_H